GridPACK: gensal.hpp Source File

00001 /*
00002  *    Copyright (c) 2013 Battelle Memorial Institute
00003  *    Licensed under modified BSD License. A copy of this license can be found
00004  *    in the LICENSE file in the top level directory of this distribution.
00005  */
00006 /*
00007  *  Created on: June 16, 2016
00008  *      Author: Bruce Palmer
00009  */
00010 #ifndef GENSAL_HPP
00011 #define GENSAL_HPP
00012 #include "gridpack/component/data_collection.hpp"
00013 #include "gridpack/parser/dictionary.hpp"
00014 #include "gridpack/utilities/string_utils.hpp"
00015 namespace gridpack {
00016 namespace parser {
00017 template <class _data_struct> class GensalParser
00018 {
00019   public:
00020     /**
00021      * Constructor
00022      */
00023     explicit GensalParser()
00024     {
00025     }
00026 
00027     /**
00028      * Destructor
00029      */
00030     virtual ~GensalParser()
00031     {
00032     }
00033 
00034     /**
00035      * Extract data from _data_struct and store it in data collection object
00036      * @param data_struct data struct object
00037      * @param data data collection object
00038      * @param gen_id index of generator
00039      */
00040     void extract(_data_struct &data_struct,
00041         gridpack::component::DataCollection *data, int g_id)
00042     {
00043       double rval;
00044       // GENERATOR_MODEL              "MODEL"        string
00045       std::string stmp;
00046       if (!data->getValue(GENERATOR_MODEL,&stmp,g_id)) {
00047         data->addValue(GENERATOR_MODEL, data_struct.model, g_id);
00048       } else {
00049         data->setValue(GENERATOR_MODEL, data_struct.model, g_id);
00050       }
00051 
00052       // GENERATOR_TDOP
00053       if (!data->getValue(GENERATOR_TDOP,&rval,g_id)) {
00054         data->addValue(GENERATOR_TDOP,data_struct.tdop, g_id);
00055       } else {
00056         data->setValue(GENERATOR_TDOP, data_struct.tdop, g_id);
00057       }
00058 
00059       // GENERATOR_TDOPP
00060       if (!data->getValue(GENERATOR_TDOPP,&rval,g_id)) {
00061         data->addValue(GENERATOR_TDOPP, data_struct.tdopp, g_id);
00062       } else {
00063         data->setValue(GENERATOR_TDOPP, data_struct.tdopp, g_id);
00064       }
00065 
00066       // GENERATOR_TQOPP
00067       if (!data->getValue(GENERATOR_TQOPP,&rval,g_id)) {
00068         data->addValue(GENERATOR_TQOPP,
00069             data_struct.tqopp, g_id);
00070       } else {
00071         data->setValue(GENERATOR_TQOPP, data_struct.tqopp, g_id);
00072       }
00073 
00074       // GENERATOR_INERTIA_CONSTANT_H                           float
00075       if (!data->getValue(GENERATOR_INERTIA_CONSTANT_H,&rval,g_id)) {
00076         data->addValue(GENERATOR_INERTIA_CONSTANT_H,
00077             data_struct.inertia, g_id);
00078       } else {
00079         data->setValue(GENERATOR_INERTIA_CONSTANT_H,
00080             data_struct.inertia, g_id);
00081       }
00082 
00083       // GENERATOR_DAMPING_COEFFICIENT_0                           float
00084       if (!data->getValue(GENERATOR_DAMPING_COEFFICIENT_0,&rval,g_id)) {
00085         data->addValue(GENERATOR_DAMPING_COEFFICIENT_0,
00086             data_struct.damping, g_id);
00087       } else {
00088         data->setValue(GENERATOR_DAMPING_COEFFICIENT_0,
00089             data_struct.damping, g_id);
00090       }
00091 
00092       // GENERATOR_XD
00093       if (!data->getValue(GENERATOR_XD,&rval,g_id)) {
00094         data->addValue(GENERATOR_XD, data_struct.gn_xd, g_id);
00095       } else {
00096         data->setValue(GENERATOR_XD, data_struct.gn_xd, g_id);
00097       }
00098 
00099       // GENERATOR_XQ
00100       if (!data->getValue(GENERATOR_XQ,&rval,g_id)) {
00101         data->addValue(GENERATOR_XQ, data_struct.gn_xq, g_id);
00102       } else {
00103         data->setValue(GENERATOR_XQ, data_struct.gn_xq, g_id);
00104       }
00105 
00106       // GENERATOR_XDP
00107       if (!data->getValue(GENERATOR_XDP,&rval,g_id)) {
00108         data->addValue(GENERATOR_XDP, data_struct.xdp, g_id);
00109       } else {
00110         data->setValue(GENERATOR_XDP, data_struct.xdp, g_id);
00111       }
00112 
00113       // GENERATOR_XDPP
00114       if (!data->getValue(GENERATOR_XDPP,&rval,g_id)) {
00115         data->addValue(GENERATOR_XDPP, data_struct.xdpp, g_id);
00116       } else {
00117         data->setValue(GENERATOR_XDPP, data_struct.xdpp, g_id);
00118       }
00119 
00120       // GENERATOR_XL
00121       if (!data->getValue(GENERATOR_XL,&rval,g_id)) {
00122         data->addValue(GENERATOR_XL,
00123             data_struct.gn_xl, g_id);
00124       } else {
00125         data->setValue(GENERATOR_XL,
00126             data_struct.gn_xl, g_id);
00127       }
00128 
00129       // GENERATOR_S1
00130       if (!data->getValue(GENERATOR_S1,&rval,g_id)) {
00131         data->addValue(GENERATOR_XL, data_struct.gn_s1, g_id);
00132       } else {
00133         data->setValue(GENERATOR_S1, data_struct.gn_s1, g_id);
00134       }
00135 
00136       // GENERATOR_S12
00137       if (!data->getValue(GENERATOR_S12,&rval,g_id)) {
00138         data->addValue(GENERATOR_XL, data_struct.s12, g_id);
00139       } else {
00140         data->setValue(GENERATOR_S12, data_struct.s12, g_id);
00141       }
00142     }
00143 
00144     /**
00145      * Parser list of strings and store results in data collection object
00146      * @param split_line list of tokens from .dyr file
00147      * @param data data collection object
00148      * @param gen_id index of generator
00149      */
00150     void parse(std::vector<std::string> &split_line,
00151         gridpack::component::DataCollection *data, int g_id)
00152     {
00153       double rval;
00154       int nstr = split_line.size();
00155       // GENERATOR_MODEL              "MODEL"                  string
00156       std::string stmp, model;
00157       gridpack::utility::StringUtils util;
00158       model = util.trimQuotes(split_line[1]);
00159       util.toUpper(model);
00160       if (!data->getValue(GENERATOR_MODEL, &stmp, g_id)) {
00161         data->addValue(GENERATOR_MODEL, model.c_str(), g_id);
00162       } else {
00163         data->setValue(GENERATOR_MODEL, model.c_str(), g_id);
00164       }
00165 
00166       // GENERATOR_TDOP
00167       if (nstr > 3) {
00168         if (!data->getValue(GENERATOR_TDOP,&rval,g_id)) {
00169           data->addValue(GENERATOR_TDOP,
00170               atof(split_line[3].c_str()), g_id);
00171         } else {
00172           data->setValue(GENERATOR_TDOP,
00173               atof(split_line[3].c_str()), g_id);
00174         }
00175       } 
00176 
00177       // GENERATOR_TDOPP
00178       if (nstr > 4) {
00179         if (!data->getValue(GENERATOR_TDOPP,&rval,g_id)) {
00180           data->addValue(GENERATOR_TDOPP,
00181               atof(split_line[4].c_str()), g_id);
00182         } else {
00183           data->setValue(GENERATOR_TDOPP,
00184               atof(split_line[4].c_str()), g_id);
00185         }
00186       } 
00187 
00188       // GENERATOR_TQOPP
00189       if (nstr > 5) {
00190         if (!data->getValue(GENERATOR_TQOPP,&rval,g_id)) {
00191           data->addValue(GENERATOR_TQOPP,
00192               atof(split_line[5].c_str()), g_id);
00193         } else {
00194           data->setValue(GENERATOR_TQOPP,
00195               atof(split_line[5].c_str()), g_id);
00196         }
00197       } 
00198 
00199       // GENERATOR_INERTIA_CONSTANT_H                           float
00200       if (nstr > 6) {
00201         if (!data->getValue(GENERATOR_INERTIA_CONSTANT_H,&rval,g_id)) {
00202           data->addValue(GENERATOR_INERTIA_CONSTANT_H,
00203               atof(split_line[6].c_str()), g_id);
00204         } else {
00205           data->setValue(GENERATOR_INERTIA_CONSTANT_H,
00206               atof(split_line[6].c_str()), g_id);
00207         }
00208       } 
00209 
00210       // GENERATOR_DAMPING_COEFFICIENT_0                           float
00211       if (nstr > 7) {
00212         if (!data->getValue(GENERATOR_DAMPING_COEFFICIENT_0,&rval,g_id)) {
00213           data->addValue(GENERATOR_DAMPING_COEFFICIENT_0,
00214               atof(split_line[7].c_str()), g_id);
00215         } else {
00216           data->setValue(GENERATOR_DAMPING_COEFFICIENT_0,
00217               atof(split_line[7].c_str()), g_id);
00218         }
00219       }
00220 
00221       // GENERATOR_XD
00222       if (nstr > 8) {
00223         if (!data->getValue(GENERATOR_XD,&rval,g_id)) {
00224           data->addValue(GENERATOR_XD,
00225               atof(split_line[8].c_str()), g_id);
00226         } else {
00227           data->setValue(GENERATOR_XD,
00228               atof(split_line[8].c_str()), g_id);
00229         }
00230       } 
00231 
00232       // GENERATOR_XQ
00233       if (nstr > 9) {
00234         if (!data->getValue(GENERATOR_XQ,&rval,g_id)) {
00235           data->addValue(GENERATOR_XQ,
00236               atof(split_line[9].c_str()), g_id);
00237         } else {
00238           data->setValue(GENERATOR_XQ,
00239               atof(split_line[9].c_str()), g_id);
00240         }
00241       } 
00242 
00243       // GENERATOR_XDP
00244       if (nstr > 10) {
00245         if (!data->getValue(GENERATOR_XDP,&rval,g_id)) {
00246           data->addValue(GENERATOR_XDP,
00247               atof(split_line[10].c_str()), g_id);
00248         } else {
00249           data->setValue(GENERATOR_XDP,
00250               atof(split_line[10].c_str()), g_id);
00251         }
00252       } 
00253 
00254       // GENERATOR_XDPP
00255       if (nstr > 11) {
00256         if (!data->getValue(GENERATOR_XDPP,&rval,g_id)) {
00257           data->addValue(GENERATOR_XDPP,
00258               atof(split_line[11].c_str()), g_id);
00259         } else {
00260           data->setValue(GENERATOR_XDPP,
00261               atof(split_line[11].c_str()), g_id);
00262         }
00263       } 
00264 
00265       // GENERATOR_XL
00266       if (nstr > 12) {
00267         if (!data->getValue(GENERATOR_XL,&rval,g_id)) {
00268           data->addValue(GENERATOR_XL,
00269               atof(split_line[12].c_str()), g_id);
00270         } else {
00271           data->setValue(GENERATOR_XL,
00272               atof(split_line[12].c_str()), g_id);
00273         }
00274       } 
00275 
00276       // GENERATOR_S1
00277       if (nstr > 13) {
00278         if (!data->getValue(GENERATOR_S1,&rval,g_id)) {
00279           data->addValue(GENERATOR_XL,
00280               atof(split_line[13].c_str()), g_id);
00281         } else {
00282           data->setValue(GENERATOR_S1,
00283               atof(split_line[13].c_str()), g_id);
00284         }
00285       } 
00286 
00287       // GENERATOR_S12
00288       if (nstr > 14) {
00289         if (!data->getValue(GENERATOR_S12,&rval,g_id)) {
00290           data->addValue(GENERATOR_XL,
00291               atof(split_line[14].c_str()), g_id);
00292         } else {
00293           data->setValue(GENERATOR_S12,
00294               atof(split_line[14].c_str()), g_id);
00295         }
00296       } 
00297     }
00298 
00299     /**
00300      * Parse list of strings store results in data_struct object
00301      * @param split_line list of tokens from .dyr file
00302      * @param data data struct that stores information from file
00303      */
00304     void store(std::vector<std::string> &split_line,_data_struct &data)
00305     {
00306       // GENERATOR_BUSNUMBER               "I"                   integer
00307       int o_idx;
00308       o_idx = atoi(split_line[0].c_str());
00309       data.bus_id = o_idx;
00310 
00311       // Clean up 2 character tag for generator ID
00312       gridpack::utility::StringUtils util;
00313       std::string tag = util.clean2Char(split_line[2]);
00314       strcpy(data.gen_id, tag.c_str());
00315 
00316       std::string sval;
00317 
00318       sval = util.trimQuotes(split_line[1]);
00319       util.toUpper(sval);
00320 
00321       // GENERATOR_MODEL              "MODEL"                  integer
00322       strcpy(data.model, sval.c_str());
00323 
00324       int nstr = split_line.size();
00325       // GENERATOR_TDOP
00326       if (nstr > 3) {
00327         data.tdop = atof(split_line[3].c_str());
00328       } 
00329 
00330       // GENERATOR_TDOPP
00331       if (nstr > 4) {
00332         data.tdopp = atof(split_line[4].c_str());
00333       } 
00334 
00335       // GENERATOR_TQOPP
00336       if (nstr > 5) {
00337         data.tqopp = atof(split_line[5].c_str());
00338       } 
00339 
00340       // GENERATOR_INERTIA_CONSTANT_H                           float
00341       if (nstr > 6) {
00342         data.inertia = atof(split_line[6].c_str());
00343       } 
00344 
00345       // GENERATOR_DAMPING_COEFFICIENT_0                           float
00346       if (nstr > 7) {
00347         data.damping = atof(split_line[7].c_str());
00348       }
00349 
00350       // GENERATOR_XD
00351       if (nstr > 8) {
00352         data.gn_xd = atof(split_line[8].c_str());
00353       } 
00354 
00355       // GENERATOR_XQ
00356       if (nstr > 9) {
00357         data.gn_xq = atof(split_line[9].c_str());
00358       } 
00359 
00360       // GENERATOR_XDP
00361       if (nstr > 10) {
00362         data.xdp = atof(split_line[10].c_str());
00363       } 
00364 
00365       // GENERATOR_XDPP
00366       if (nstr > 11) {
00367         data.xdpp = atof(split_line[11].c_str());
00368       } 
00369 
00370       // GENERATOR_XL
00371       if (nstr > 12) {
00372         data.gn_xl = atof(split_line[12].c_str());
00373       } 
00374 
00375       // GENERATOR_S1
00376       if (nstr > 13) {
00377         data.gn_s1 = atof(split_line[13].c_str());
00378       } 
00379 
00380       // GENERATOR_S12
00381       if (nstr > 14) {
00382         data.s12 = atof(split_line[14].c_str());
00383       } 
00384     }
00385 };
00386 }  // parser
00387 }  // gridpack
00388 #endif